YES 22.128 H-Termination proof of /home/matraf/haskell/eval_FullyBlown_Fast/List.hs
H-Termination of the given Haskell-Program with start terms could successfully be proven:



HASKELL
  ↳ IFR

mainModule List
  ((union :: [Int ->  [Int ->  [Int]) :: [Int ->  [Int ->  [Int])

module List where
  import qualified Maybe
import qualified Prelude

  deleteBy :: (a  ->  a  ->  Bool ->  a  ->  [a ->  [a]
deleteBy _ _ [] []
deleteBy eq x (y : ys if x `eq` y then ys else y : deleteBy eq x ys

  elem_by :: (a  ->  a  ->  Bool ->  a  ->  [a ->  Bool
elem_by _ _ [] False
elem_by eq y (x : xsx `eq` y || elem_by eq y xs

  nubBy :: (a  ->  a  ->  Bool ->  [a ->  [a]
nubBy eq l 
nubBy' l [] where 
nubBy' [] _ []
nubBy' (y : ysxs 
 | elem_by eq y xs = 
nubBy' ys xs
 | otherwise = 
y : nubBy' ys (y : xs)

  union :: Eq a => [a ->  [a ->  [a]
union unionBy (==)

  unionBy :: (a  ->  a  ->  Bool ->  [a ->  [a ->  [a]
unionBy eq xs ys xs ++ foldl (flip (deleteBy eq)) (nubBy eq ys) xs


module Maybe where
  import qualified List
import qualified Prelude



If Reductions:
The following If expression
if eq x y then ys else y : deleteBy eq x ys

is transformed to
deleteBy0 ys y eq x True = ys
deleteBy0 ys y eq x False = y : deleteBy eq x ys



↳ HASKELL
  ↳ IFR
HASKELL
      ↳ BR

mainModule List
  ((union :: [Int ->  [Int ->  [Int]) :: [Int ->  [Int ->  [Int])

module List where
  import qualified Maybe
import qualified Prelude

  deleteBy :: (a  ->  a  ->  Bool ->  a  ->  [a ->  [a]
deleteBy _ _ [] []
deleteBy eq x (y : ysdeleteBy0 ys y eq x (x `eq` y)

  
deleteBy0 ys y eq x True ys
deleteBy0 ys y eq x False y : deleteBy eq x ys

  elem_by :: (a  ->  a  ->  Bool ->  a  ->  [a ->  Bool
elem_by _ _ [] False
elem_by eq y (x : xsx `eq` y || elem_by eq y xs

  nubBy :: (a  ->  a  ->  Bool ->  [a ->  [a]
nubBy eq l 
nubBy' l [] where 
nubBy' [] _ []
nubBy' (y : ysxs 
 | elem_by eq y xs = 
nubBy' ys xs
 | otherwise = 
y : nubBy' ys (y : xs)

  union :: Eq a => [a ->  [a ->  [a]
union unionBy (==)

  unionBy :: (a  ->  a  ->  Bool ->  [a ->  [a ->  [a]
unionBy eq xs ys xs ++ foldl (flip (deleteBy eq)) (nubBy eq ys) xs


module Maybe where
  import qualified List
import qualified Prelude



Replaced joker patterns by fresh variables and removed binding patterns.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
HASKELL
          ↳ COR

mainModule List
  ((union :: [Int ->  [Int ->  [Int]) :: [Int ->  [Int ->  [Int])

module List where
  import qualified Maybe
import qualified Prelude

  deleteBy :: (a  ->  a  ->  Bool ->  a  ->  [a ->  [a]
deleteBy vw vx [] []
deleteBy eq x (y : ysdeleteBy0 ys y eq x (x `eq` y)

  
deleteBy0 ys y eq x True ys
deleteBy0 ys y eq x False y : deleteBy eq x ys

  elem_by :: (a  ->  a  ->  Bool ->  a  ->  [a ->  Bool
elem_by vz wu [] False
elem_by eq y (x : xsx `eq` y || elem_by eq y xs

  nubBy :: (a  ->  a  ->  Bool ->  [a ->  [a]
nubBy eq l 
nubBy' l [] where 
nubBy' [] vy []
nubBy' (y : ysxs 
 | elem_by eq y xs = 
nubBy' ys xs
 | otherwise = 
y : nubBy' ys (y : xs)

  union :: Eq a => [a ->  [a ->  [a]
union unionBy (==)

  unionBy :: (a  ->  a  ->  Bool ->  [a ->  [a ->  [a]
unionBy eq xs ys xs ++ foldl (flip (deleteBy eq)) (nubBy eq ys) xs


module Maybe where
  import qualified List
import qualified Prelude



Cond Reductions:
The following Function with conditions
nubBy' [] vy = []
nubBy' (y : ysxs
 | elem_by eq y xs
 = nubBy' ys xs
 | otherwise
 = y : nubBy' ys (y : xs)

is transformed to
nubBy' [] vy = nubBy'3 [] vy
nubBy' (y : ysxs = nubBy'2 (y : ysxs

nubBy'1 y ys xs True = nubBy' ys xs
nubBy'1 y ys xs False = nubBy'0 y ys xs otherwise

nubBy'0 y ys xs True = y : nubBy' ys (y : xs)

nubBy'2 (y : ysxs = nubBy'1 y ys xs (elem_by eq y xs)

nubBy'3 [] vy = []
nubBy'3 xv xw = nubBy'2 xv xw

The following Function with conditions
undefined 
 | False
 = undefined

is transformed to
undefined  = undefined1

undefined0 True = undefined

undefined1  = undefined0 False



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
HASKELL
              ↳ LetRed

mainModule List
  ((union :: [Int ->  [Int ->  [Int]) :: [Int ->  [Int ->  [Int])

module List where
  import qualified Maybe
import qualified Prelude

  deleteBy :: (a  ->  a  ->  Bool ->  a  ->  [a ->  [a]
deleteBy vw vx [] []
deleteBy eq x (y : ysdeleteBy0 ys y eq x (x `eq` y)

  
deleteBy0 ys y eq x True ys
deleteBy0 ys y eq x False y : deleteBy eq x ys

  elem_by :: (a  ->  a  ->  Bool ->  a  ->  [a ->  Bool
elem_by vz wu [] False
elem_by eq y (x : xsx `eq` y || elem_by eq y xs

  nubBy :: (a  ->  a  ->  Bool ->  [a ->  [a]
nubBy eq l 
nubBy' l [] where 
nubBy' [] vy nubBy'3 [] vy
nubBy' (y : ysxs nubBy'2 (y : ys) xs
nubBy'0 y ys xs True y : nubBy' ys (y : xs)
nubBy'1 y ys xs True nubBy' ys xs
nubBy'1 y ys xs False nubBy'0 y ys xs otherwise
nubBy'2 (y : ysxs nubBy'1 y ys xs (elem_by eq y xs)
nubBy'3 [] vy []
nubBy'3 xv xw nubBy'2 xv xw

  union :: Eq a => [a ->  [a ->  [a]
union unionBy (==)

  unionBy :: (a  ->  a  ->  Bool ->  [a ->  [a ->  [a]
unionBy eq xs ys xs ++ foldl (flip (deleteBy eq)) (nubBy eq ys) xs


module Maybe where
  import qualified List
import qualified Prelude



Let/Where Reductions:
The bindings of the following Let/Where expression
nubBy' l []
where 
nubBy' [] vy = nubBy'3 [] vy
nubBy' (y : ysxs = nubBy'2 (y : ysxs
nubBy'0 y ys xs True = y : nubBy' ys (y : xs)
nubBy'1 y ys xs True = nubBy' ys xs
nubBy'1 y ys xs False = nubBy'0 y ys xs otherwise
nubBy'2 (y : ysxs = nubBy'1 y ys xs (elem_by eq y xs)
nubBy'3 [] vy = []
nubBy'3 xv xw = nubBy'2 xv xw

are unpacked to the following functions on top level
nubByNubBy'1 xx y ys xs True = nubByNubBy' xx ys xs
nubByNubBy'1 xx y ys xs False = nubByNubBy'0 xx y ys xs otherwise

nubByNubBy'3 xx [] vy = []
nubByNubBy'3 xx xv xw = nubByNubBy'2 xx xv xw

nubByNubBy'2 xx (y : ysxs = nubByNubBy'1 xx y ys xs (elem_by xx y xs)

nubByNubBy'0 xx y ys xs True = y : nubByNubBy' xx ys (y : xs)

nubByNubBy' xx [] vy = nubByNubBy'3 xx [] vy
nubByNubBy' xx (y : ysxs = nubByNubBy'2 xx (y : ysxs



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
HASKELL
                  ↳ Narrow

mainModule List
  (union :: [Int ->  [Int ->  [Int])

module List where
  import qualified Maybe
import qualified Prelude

  deleteBy :: (a  ->  a  ->  Bool ->  a  ->  [a ->  [a]
deleteBy vw vx [] []
deleteBy eq x (y : ysdeleteBy0 ys y eq x (x `eq` y)

  
deleteBy0 ys y eq x True ys
deleteBy0 ys y eq x False y : deleteBy eq x ys

  elem_by :: (a  ->  a  ->  Bool ->  a  ->  [a ->  Bool
elem_by vz wu [] False
elem_by eq y (x : xsx `eq` y || elem_by eq y xs

  nubBy :: (a  ->  a  ->  Bool ->  [a ->  [a]
nubBy eq l nubByNubBy' eq l []

  
nubByNubBy' xx [] vy nubByNubBy'3 xx [] vy
nubByNubBy' xx (y : ysxs nubByNubBy'2 xx (y : ys) xs

  
nubByNubBy'0 xx y ys xs True y : nubByNubBy' xx ys (y : xs)

  
nubByNubBy'1 xx y ys xs True nubByNubBy' xx ys xs
nubByNubBy'1 xx y ys xs False nubByNubBy'0 xx y ys xs otherwise

  
nubByNubBy'2 xx (y : ysxs nubByNubBy'1 xx y ys xs (elem_by xx y xs)

  
nubByNubBy'3 xx [] vy []
nubByNubBy'3 xx xv xw nubByNubBy'2 xx xv xw

  union :: Eq a => [a ->  [a ->  [a]
union unionBy (==)

  unionBy :: (a  ->  a  ->  Bool ->  [a ->  [a ->  [a]
unionBy eq xs ys xs ++ foldl (flip (deleteBy eq)) (nubBy eq ys) xs


module Maybe where
  import qualified List
import qualified Prelude



Haskell To QDPs


↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
QDP
                        ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primEqNat(Succ(xy10000), Succ(xy90000)) → new_primEqNat(xy10000, xy90000)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
QDP
                        ↳ DependencyGraphProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_nubByNubBy'1(xy381, xy382, xy383, xy384, False, :(xy3860, xy3861)) → new_nubByNubBy'1(xy381, xy382, xy383, xy384, new_primEqInt(xy3860, xy381), xy3861)
new_nubByNubBy'10(xy381, xy382, xy383, xy384, []) → new_nubByNubBy'(xy382, xy381, :(xy383, xy384))
new_nubByNubBy'1(xy381, xy382, xy383, xy384, False, []) → new_nubByNubBy'(xy382, xy381, :(xy383, xy384))
new_nubByNubBy'10(xy381, xy382, xy383, xy384, :(xy3860, xy3861)) → new_nubByNubBy'1(xy381, xy382, xy383, xy384, new_primEqInt(xy3860, xy381), xy3861)
new_nubByNubBy'1(xy381, :(xy3820, xy3821), xy383, xy384, True, xy386) → new_nubByNubBy'10(xy3820, xy3821, xy383, xy384, :(xy383, xy384))
new_nubByNubBy'(:(xy3820, xy3821), xy383, xy384) → new_nubByNubBy'10(xy3820, xy3821, xy383, xy384, :(xy383, xy384))

The TRS R consists of the following rules:

new_primEqNat0(Succ(xy10000), Zero) → False
new_primEqNat0(Zero, Succ(xy90000)) → False
new_primEqInt(Neg(Zero), Pos(Succ(xy9000))) → False
new_primEqInt(Pos(Zero), Neg(Succ(xy9000))) → False
new_primEqInt(Pos(Zero), Pos(Zero)) → True
new_primEqInt(Neg(Zero), Neg(Succ(xy9000))) → False
new_primEqInt(Neg(Succ(xy1000)), Neg(Zero)) → False
new_primEqNat0(Succ(xy10000), Succ(xy90000)) → new_primEqNat0(xy10000, xy90000)
new_primEqNat0(Zero, Zero) → True
new_primEqInt(Pos(Zero), Pos(Succ(xy9000))) → False
new_primEqInt(Pos(Succ(xy1000)), Pos(Zero)) → False
new_primEqInt(Neg(Succ(xy1000)), Pos(xy900)) → False
new_primEqInt(Pos(Succ(xy1000)), Neg(xy900)) → False
new_primEqInt(Neg(Zero), Pos(Zero)) → True
new_primEqInt(Pos(Zero), Neg(Zero)) → True
new_primEqInt(Pos(Succ(xy1000)), Pos(Succ(xy9000))) → new_primEqNat0(xy1000, xy9000)
new_primEqInt(Neg(Zero), Neg(Zero)) → True
new_primEqInt(Neg(Succ(xy1000)), Neg(Succ(xy9000))) → new_primEqNat0(xy1000, xy9000)

The set Q consists of the following terms:

new_primEqInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_primEqInt(Neg(Zero), Pos(Zero))
new_primEqInt(Pos(Zero), Neg(Zero))
new_primEqInt(Pos(Zero), Pos(Zero))
new_primEqNat0(Zero, Zero)
new_primEqInt(Pos(Succ(x0)), Neg(x1))
new_primEqInt(Neg(Succ(x0)), Pos(x1))
new_primEqNat0(Succ(x0), Zero)
new_primEqNat0(Zero, Succ(x0))
new_primEqNat0(Succ(x0), Succ(x1))
new_primEqInt(Pos(Succ(x0)), Pos(Zero))
new_primEqInt(Neg(Zero), Neg(Zero))
new_primEqInt(Pos(Zero), Neg(Succ(x0)))
new_primEqInt(Neg(Zero), Pos(Succ(x0)))
new_primEqInt(Neg(Succ(x0)), Neg(Zero))
new_primEqInt(Neg(Zero), Neg(Succ(x0)))
new_primEqInt(Pos(Zero), Pos(Succ(x0)))
new_primEqInt(Pos(Succ(x0)), Pos(Succ(x1)))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                        ↳ DependencyGraphProof
QDP
                            ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_nubByNubBy'1(xy381, xy382, xy383, xy384, False, :(xy3860, xy3861)) → new_nubByNubBy'1(xy381, xy382, xy383, xy384, new_primEqInt(xy3860, xy381), xy3861)
new_nubByNubBy'1(xy381, xy382, xy383, xy384, False, []) → new_nubByNubBy'(xy382, xy381, :(xy383, xy384))
new_nubByNubBy'10(xy381, xy382, xy383, xy384, :(xy3860, xy3861)) → new_nubByNubBy'1(xy381, xy382, xy383, xy384, new_primEqInt(xy3860, xy381), xy3861)
new_nubByNubBy'1(xy381, :(xy3820, xy3821), xy383, xy384, True, xy386) → new_nubByNubBy'10(xy3820, xy3821, xy383, xy384, :(xy383, xy384))
new_nubByNubBy'(:(xy3820, xy3821), xy383, xy384) → new_nubByNubBy'10(xy3820, xy3821, xy383, xy384, :(xy383, xy384))

The TRS R consists of the following rules:

new_primEqNat0(Succ(xy10000), Zero) → False
new_primEqNat0(Zero, Succ(xy90000)) → False
new_primEqInt(Neg(Zero), Pos(Succ(xy9000))) → False
new_primEqInt(Pos(Zero), Neg(Succ(xy9000))) → False
new_primEqInt(Pos(Zero), Pos(Zero)) → True
new_primEqInt(Neg(Zero), Neg(Succ(xy9000))) → False
new_primEqInt(Neg(Succ(xy1000)), Neg(Zero)) → False
new_primEqNat0(Succ(xy10000), Succ(xy90000)) → new_primEqNat0(xy10000, xy90000)
new_primEqNat0(Zero, Zero) → True
new_primEqInt(Pos(Zero), Pos(Succ(xy9000))) → False
new_primEqInt(Pos(Succ(xy1000)), Pos(Zero)) → False
new_primEqInt(Neg(Succ(xy1000)), Pos(xy900)) → False
new_primEqInt(Pos(Succ(xy1000)), Neg(xy900)) → False
new_primEqInt(Neg(Zero), Pos(Zero)) → True
new_primEqInt(Pos(Zero), Neg(Zero)) → True
new_primEqInt(Pos(Succ(xy1000)), Pos(Succ(xy9000))) → new_primEqNat0(xy1000, xy9000)
new_primEqInt(Neg(Zero), Neg(Zero)) → True
new_primEqInt(Neg(Succ(xy1000)), Neg(Succ(xy9000))) → new_primEqNat0(xy1000, xy9000)

The set Q consists of the following terms:

new_primEqInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_primEqInt(Neg(Zero), Pos(Zero))
new_primEqInt(Pos(Zero), Neg(Zero))
new_primEqInt(Pos(Zero), Pos(Zero))
new_primEqNat0(Zero, Zero)
new_primEqInt(Pos(Succ(x0)), Neg(x1))
new_primEqInt(Neg(Succ(x0)), Pos(x1))
new_primEqNat0(Succ(x0), Zero)
new_primEqNat0(Zero, Succ(x0))
new_primEqNat0(Succ(x0), Succ(x1))
new_primEqInt(Pos(Succ(x0)), Pos(Zero))
new_primEqInt(Neg(Zero), Neg(Zero))
new_primEqInt(Pos(Zero), Neg(Succ(x0)))
new_primEqInt(Neg(Zero), Pos(Succ(x0)))
new_primEqInt(Neg(Succ(x0)), Neg(Zero))
new_primEqInt(Neg(Zero), Neg(Succ(x0)))
new_primEqInt(Pos(Zero), Pos(Succ(x0)))
new_primEqInt(Pos(Succ(x0)), Pos(Succ(x1)))

We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
QDP
                        ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_deleteBy(xy10, :(xy90, xy91), bb) → new_deleteBy0(xy91, xy90, xy10, new_esEs(xy10, xy90, bb), bb)
new_deleteBy0(xy17, xy18, xy19, False, ba) → new_deleteBy(xy19, xy17, ba)

The TRS R consists of the following rules:

new_esEs(xy10, xy90, ty_Ordering) → error([])
new_esEs(xy10, xy90, ty_@0) → error([])
new_esEs(xy10, xy90, app(ty_Ratio, cc)) → error([])
new_esEs(xy10, xy90, ty_Char) → error([])
new_primEqInt(Neg(Succ(xy1000)), Neg(Zero)) → False
new_primEqInt(Neg(Zero), Neg(Succ(xy9000))) → False
new_esEs(xy10, xy90, ty_Bool) → error([])
new_primEqNat0(Succ(xy10000), Succ(xy90000)) → new_primEqNat0(xy10000, xy90000)
new_primEqNat0(Zero, Zero) → True
new_primEqInt(Pos(Succ(xy1000)), Neg(xy900)) → False
new_primEqInt(Neg(Succ(xy1000)), Pos(xy900)) → False
new_esEs(xy10, xy90, app(app(ty_Either, bd), be)) → error([])
new_esEs(xy10, xy90, ty_Int) → new_primEqInt(xy10, xy90)
new_primEqInt(Neg(Succ(xy1000)), Neg(Succ(xy9000))) → new_primEqNat0(xy1000, xy9000)
new_esEs(xy10, xy90, app(app(app(ty_@3, bf), bg), bh)) → error([])
new_esEs(xy10, xy90, ty_Double) → error([])
new_primEqNat0(Succ(xy10000), Zero) → False
new_primEqNat0(Zero, Succ(xy90000)) → False
new_esEs(xy10, xy90, ty_Integer) → error([])
new_primEqInt(Pos(Zero), Neg(Succ(xy9000))) → False
new_primEqInt(Neg(Zero), Pos(Succ(xy9000))) → False
new_esEs(xy10, xy90, app(app(ty_@2, ca), cb)) → error([])
new_esEs(xy10, xy90, app(ty_[], bc)) → error([])
new_primEqInt(Pos(Zero), Pos(Zero)) → True
new_primEqInt(Pos(Succ(xy1000)), Pos(Zero)) → False
new_primEqInt(Pos(Zero), Pos(Succ(xy9000))) → False
new_primEqInt(Pos(Zero), Neg(Zero)) → True
new_primEqInt(Neg(Zero), Pos(Zero)) → True
new_esEs(xy10, xy90, ty_Float) → error([])
new_primEqInt(Pos(Succ(xy1000)), Pos(Succ(xy9000))) → new_primEqNat0(xy1000, xy9000)
new_esEs(xy10, xy90, app(ty_Maybe, cd)) → error([])
new_primEqInt(Neg(Zero), Neg(Zero)) → True

The set Q consists of the following terms:

new_esEs(x0, x1, ty_Integer)
new_esEs(x0, x1, ty_@0)
new_primEqInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_primEqInt(Pos(Zero), Pos(Zero))
new_primEqInt(Pos(Succ(x0)), Neg(x1))
new_primEqInt(Neg(Succ(x0)), Pos(x1))
new_esEs(x0, x1, ty_Ordering)
new_esEs(x0, x1, ty_Int)
new_primEqNat0(Zero, Succ(x0))
new_primEqInt(Neg(Zero), Neg(Zero))
new_esEs(x0, x1, ty_Float)
new_primEqInt(Neg(Succ(x0)), Neg(Zero))
new_primEqInt(Pos(Zero), Pos(Succ(x0)))
new_esEs(x0, x1, app(ty_Maybe, x2))
new_esEs(x0, x1, app(app(ty_Either, x2), x3))
new_esEs(x0, x1, ty_Double)
new_primEqInt(Pos(Zero), Neg(Zero))
new_primEqInt(Neg(Zero), Pos(Zero))
new_primEqNat0(Zero, Zero)
new_primEqNat0(Succ(x0), Zero)
new_esEs(x0, x1, ty_Bool)
new_esEs(x0, x1, ty_Char)
new_esEs(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_primEqInt(Pos(Succ(x0)), Pos(Zero))
new_primEqNat0(Succ(x0), Succ(x1))
new_primEqInt(Neg(Zero), Pos(Succ(x0)))
new_primEqInt(Pos(Zero), Neg(Succ(x0)))
new_primEqInt(Neg(Zero), Neg(Succ(x0)))
new_esEs(x0, x1, app(ty_[], x2))
new_esEs(x0, x1, app(app(ty_@2, x2), x3))
new_esEs(x0, x1, app(ty_Ratio, x2))
new_primEqInt(Pos(Succ(x0)), Pos(Succ(x1)))

We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
QDP
                        ↳ QDPSizeChangeProof
                      ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_foldl(xy9, xy10, :(xy110, xy111), ba) → new_foldl(new_flip(xy9, xy10, ba), xy110, xy111, ba)

The TRS R consists of the following rules:

new_esEs(xy10, xy90, ty_Ordering) → error([])
new_esEs(xy10, xy90, ty_@0) → error([])
new_esEs(xy10, xy90, app(ty_Ratio, cb)) → error([])
new_deleteBy00(xy17, xy18, xy19, True, cd) → xy17
new_esEs(xy10, xy90, ty_Char) → error([])
new_primEqInt(Neg(Zero), Neg(Succ(xy9000))) → False
new_primEqInt(Neg(Succ(xy1000)), Neg(Zero)) → False
new_esEs(xy10, xy90, ty_Bool) → error([])
new_primEqNat0(Zero, Zero) → True
new_primEqNat0(Succ(xy10000), Succ(xy90000)) → new_primEqNat0(xy10000, xy90000)
new_primEqInt(Pos(Succ(xy1000)), Neg(xy900)) → False
new_primEqInt(Neg(Succ(xy1000)), Pos(xy900)) → False
new_esEs(xy10, xy90, app(app(ty_Either, bc), bd)) → error([])
new_esEs(xy10, xy90, ty_Int) → new_primEqInt(xy10, xy90)
new_primEqInt(Neg(Succ(xy1000)), Neg(Succ(xy9000))) → new_primEqNat0(xy1000, xy9000)
new_deleteBy1(xy10, [], ba) → []
new_esEs(xy10, xy90, ty_Double) → error([])
new_esEs(xy10, xy90, app(app(app(ty_@3, be), bf), bg)) → error([])
new_primEqNat0(Zero, Succ(xy90000)) → False
new_primEqNat0(Succ(xy10000), Zero) → False
new_esEs(xy10, xy90, ty_Integer) → error([])
new_primEqInt(Pos(Zero), Neg(Succ(xy9000))) → False
new_primEqInt(Neg(Zero), Pos(Succ(xy9000))) → False
new_esEs(xy10, xy90, app(ty_[], bb)) → error([])
new_esEs(xy10, xy90, app(app(ty_@2, bh), ca)) → error([])
new_deleteBy00(xy17, xy18, xy19, False, cd) → :(xy18, new_deleteBy1(xy19, xy17, cd))
new_primEqInt(Pos(Zero), Pos(Zero)) → True
new_deleteBy1(xy10, :(xy90, xy91), ba) → new_deleteBy00(xy91, xy90, xy10, new_esEs(xy10, xy90, ba), ba)
new_primEqInt(Pos(Succ(xy1000)), Pos(Zero)) → False
new_primEqInt(Pos(Zero), Pos(Succ(xy9000))) → False
new_flip(xy9, xy10, ba) → new_deleteBy1(xy10, xy9, ba)
new_primEqInt(Pos(Zero), Neg(Zero)) → True
new_primEqInt(Neg(Zero), Pos(Zero)) → True
new_primEqInt(Pos(Succ(xy1000)), Pos(Succ(xy9000))) → new_primEqNat0(xy1000, xy9000)
new_esEs(xy10, xy90, ty_Float) → error([])
new_esEs(xy10, xy90, app(ty_Maybe, cc)) → error([])
new_primEqInt(Neg(Zero), Neg(Zero)) → True

The set Q consists of the following terms:

new_esEs(x0, x1, ty_Integer)
new_esEs(x0, x1, ty_@0)
new_primEqInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_primEqInt(Pos(Zero), Pos(Zero))
new_primEqInt(Pos(Succ(x0)), Neg(x1))
new_primEqInt(Neg(Succ(x0)), Pos(x1))
new_esEs(x0, x1, ty_Ordering)
new_esEs(x0, x1, ty_Int)
new_primEqNat0(Zero, Succ(x0))
new_deleteBy1(x0, :(x1, x2), x3)
new_deleteBy00(x0, x1, x2, False, x3)
new_esEs(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_primEqInt(Neg(Zero), Neg(Zero))
new_esEs(x0, x1, ty_Float)
new_primEqInt(Neg(Succ(x0)), Neg(Zero))
new_deleteBy1(x0, [], x1)
new_primEqInt(Pos(Zero), Pos(Succ(x0)))
new_esEs(x0, x1, app(ty_Ratio, x2))
new_esEs(x0, x1, ty_Double)
new_primEqInt(Pos(Zero), Neg(Zero))
new_primEqInt(Neg(Zero), Pos(Zero))
new_primEqNat0(Zero, Zero)
new_primEqNat0(Succ(x0), Zero)
new_esEs(x0, x1, ty_Bool)
new_flip(x0, x1, x2)
new_esEs(x0, x1, app(ty_[], x2))
new_esEs(x0, x1, app(app(ty_@2, x2), x3))
new_esEs(x0, x1, ty_Char)
new_esEs(x0, x1, app(ty_Maybe, x2))
new_primEqInt(Pos(Succ(x0)), Pos(Zero))
new_primEqNat0(Succ(x0), Succ(x1))
new_deleteBy00(x0, x1, x2, True, x3)
new_primEqInt(Neg(Zero), Pos(Succ(x0)))
new_primEqInt(Pos(Zero), Neg(Succ(x0)))
new_primEqInt(Neg(Zero), Neg(Succ(x0)))
new_esEs(x0, x1, app(app(ty_Either, x2), x3))
new_primEqInt(Pos(Succ(x0)), Pos(Succ(x1)))

We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
QDP
                        ↳ QDPSizeChangeProof

Q DP problem:
The TRS P consists of the following rules:

new_psPs(:(xy80, xy81), xy9, xy10, xy11, ba) → new_psPs(xy81, xy9, xy10, xy11, ba)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs: